package com.ruoyi.course.service.impl;

import com.ruoyi.course.domain.CourseSwitch;
import com.ruoyi.course.vo.CourseSwitchVO;
import com.ruoyi.course.mapper.CourseSwitchMapper;
import com.ruoyi.course.service.ICourseSwitchService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 调课记录Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-06-12
 */
@Service
public class CourseSwitchServiceImpl implements ICourseSwitchService 
{
    @Autowired
    private CourseSwitchMapper courseSwitchMapper;

    /**
     * 查询调课记录
     * 
     * @param switchId 调课记录主键
     * @return 调课记录
     */
    @Override
    public CourseSwitch selectCourseSwitchBySwitchId(Integer switchId)
    {
        return courseSwitchMapper.selectCourseSwitchBySwitchId(switchId);
    }

    /**
     * 查询调课记录列表
     * 
     * @param courseSwitch 调课记录
     * @return 调课记录
     */
    @Override
    public List<CourseSwitch> selectCourseSwitchList(CourseSwitch courseSwitch)
    {
        return courseSwitchMapper.selectCourseSwitchList(courseSwitch);
    }

    /**
     * 查询调课记录VO列表（用于前端展示）
     * 
     * @param courseSwitchVO 调课记录VO
     * @return 调课记录VO集合
     */
    @Override
    public List<CourseSwitchVO> selectCourseSwitchVOList(CourseSwitchVO courseSwitchVO)
    {
        List<CourseSwitchVO> list = courseSwitchMapper.selectCourseSwitchVOList(courseSwitchVO);
        return processCourseSwitchDisplayData(list);
    }

    /**
     * 处理调课记录显示数据
     * 根据before和after记录生成合并的显示信息
     */
    private List<CourseSwitchVO> processCourseSwitchDisplayData(List<CourseSwitchVO> list) {
        // 过滤掉已删除的记录
        List<CourseSwitchVO> activeList = list.stream()
                .filter(item -> item.getEmpty3() == null || !"0".equals(item.getEmpty3()))
                .collect(Collectors.toList());
        
        Map<String, List<CourseSwitchVO>> groupedByRelationId = activeList.stream()
                .filter(item -> item.getEmpty1() != null && !item.getEmpty1().trim().isEmpty())
                .collect(Collectors.groupingBy(CourseSwitchVO::getEmpty1));

        List<CourseSwitchVO> result = new ArrayList<>();

        for (Map.Entry<String, List<CourseSwitchVO>> entry : groupedByRelationId.entrySet()) {
            List<CourseSwitchVO> group = entry.getValue();
            
            if (group.size() == 2) {
                CourseSwitchVO beforeRecord = group.stream()
                        .filter(item -> "before".equals(item.getEmpty2()))
                        .findFirst().orElse(null);
                CourseSwitchVO afterRecord = group.stream()
                        .filter(item -> "after".equals(item.getEmpty2()))
                        .findFirst().orElse(null);

                if (beforeRecord != null && afterRecord != null) {
                    CourseSwitchVO mergedRecord = createMergedRecord(beforeRecord, afterRecord);
                    result.add(mergedRecord);
                }
            } else {
                // 如果只有一条记录或记录不完整，直接添加
                result.addAll(group);
            }
        }

        // 添加没有empty1关联ID的单独记录（也要过滤已删除的）
        activeList.stream()
                .filter(item -> item.getEmpty1() == null || item.getEmpty1().trim().isEmpty())
                .forEach(result::add);

        // 按switchId升序排序
        result.sort(Comparator.comparing(CourseSwitchVO::getSwitchId));

        return result;
    }

    /**
     * 创建合并后的显示记录
     */
    private CourseSwitchVO createMergedRecord(CourseSwitchVO beforeRecord, CourseSwitchVO afterRecord) {
        CourseSwitchVO merged = new CourseSwitchVO();
        
        // 使用after记录的基本信息作为主信息
        merged.setSwitchId(afterRecord.getSwitchId());
        merged.setCampusId(afterRecord.getCampusId());
        merged.setCampusName(afterRecord.getCampusName());
        merged.setStuId(afterRecord.getStuId());
        merged.setLessonId(afterRecord.getLessonId());
        merged.setCourseName(afterRecord.getCourseName());
        merged.setClaId(afterRecord.getClaId());
        merged.setClaName(afterRecord.getClaName());
        merged.setCreTime(afterRecord.getCreTime());
        merged.setUpdTime(afterRecord.getUpdTime());
        merged.setEmpty1(afterRecord.getEmpty1());
        merged.setEmpty2("merged");

        // 处理日期显示逻辑
        String beforeDate = beforeRecord.getWeekDay();
        String afterDate = afterRecord.getWeekDay();
        String beforeTime = beforeRecord.getTimeFrame();
        String afterTime = afterRecord.getTimeFrame();

        if (Objects.equals(beforeDate, afterDate)) {
            // 日期相同，显示一个日期
            merged.setDisplayWeekDay(afterDate);
            merged.setWeekDay(afterDate);
            
            if (Objects.equals(beforeTime, afterTime)) {
                // 时段也相同，只显示一个时段
                merged.setDisplayTimeFrame(afterTime);
                merged.setTimeFrame(afterTime);
            } else {
                // 时段不同，显示 before时段 ➡ after时段
                merged.setDisplayTimeFrame(beforeTime + " ➡ " + afterTime);
                merged.setTimeFrame(afterTime);
            }
        } else {
            // 日期不同，显示 before日期 ➡ after日期
            merged.setDisplayWeekDay(beforeDate + " ➡ " + afterDate);
            merged.setWeekDay(afterDate);
            merged.setDisplayTimeFrame(afterTime);
            merged.setTimeFrame(afterTime);
        }

        return merged;
    }

    /**
     * 新增调课记录
     * 
     * @param courseSwitch 调课记录
     * @return 结果
     */
    @Override
    public int insertCourseSwitch(CourseSwitch courseSwitch)
    {
        return courseSwitchMapper.insertCourseSwitch(courseSwitch);
    }

    /**
     * 修改调课记录
     * 
     * @param courseSwitch 调课记录
     * @return 结果
     */
    @Override
    public int updateCourseSwitch(CourseSwitch courseSwitch)
    {
        return courseSwitchMapper.updateCourseSwitch(courseSwitch);
    }

    /**
     * 批量删除调课记录
     * 
     * @param switchIds 需要删除的调课记录主键
     * @return 结果
     */
    @Override
    public int deleteCourseSwitchBySwitchIds(Integer[] switchIds)
    {
        return courseSwitchMapper.deleteCourseSwitchBySwitchIds(switchIds);
    }

    /**
     * 删除调课记录信息
     * 
     * @param switchId 调课记录主键
     * @return 结果
     */
    @Override
    public int deleteCourseSwitchBySwitchId(Integer switchId)
    {
        return courseSwitchMapper.deleteCourseSwitchBySwitchId(switchId);
    }

    /**
     * 假删除调课记录（同时删除对应的成对记录）
     * 
     * @param switchId 调课记录主键
     * @return 结果
     */
    @Override
    public int softDeleteCourseSwitch(Integer switchId)
    {
        // 首先获取要删除的记录信息
        CourseSwitch courseSwitch = courseSwitchMapper.selectCourseSwitchBySwitchId(switchId);
        if (courseSwitch == null) {
            return 0;
        }

        // 如果该记录有关联ID（empty1），则删除整个成对记录
        if (courseSwitch.getEmpty1() != null && !courseSwitch.getEmpty1().trim().isEmpty()) {
            return courseSwitchMapper.softDeleteCourseSwitchByRelationId(courseSwitch.getEmpty1());
        } else {
            // 如果没有关联ID，只删除单条记录
            return courseSwitchMapper.softDeleteCourseSwitch(switchId);
        }
    }

    /**
     * 批量假删除调课记录（同时删除对应的成对记录）
     * @param switchIds 需要删除的调课记录主键集合
     * @return 结果
     */
    @Override
    public int softDeleteCourseSwitchBySwitchIds(Integer[] switchIds)
    {
        return courseSwitchMapper.softDeleteCourseSwitchBySwitchIds(switchIds);
    }
}
